import axios from 'axios'
import { API_BASE_URL, AI_CHAT_API_BASE_URL } from '../utils/constants'
import { getToken, removeToken } from '@/utils/auth'
import { ElMessage } from 'element-plus'

const api = axios.create({
  baseURL: API_BASE_URL,
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
api.interceptors.request.use(
  (config) => {
    // 是否需要 token（某些接口不需要 token，如登录接口）
    const isToken = (config.headers || {}).isToken !== false
    if (getToken() && isToken) {
      config.headers['Authorization'] = 'Bearer ' + getToken()
    }
    return config
  },
  (error) => {
    console.log(error)
    return Promise.reject(error)
  }
)

// 响应拦截器
api.interceptors.response.use(
  (res) => {
    // 二进制数据则直接返回
    if (res.request.responseType === 'blob' || res.request.responseType === 'arraybuffer') {
      return res.data
    }
    
    // 未设置状态码则默认成功状态
    const code = res.data?.code || 200
    // 获取错误信息
    const msg = res.data?.msg || '请求失败'
    
    if (code === 401) {
      ElMessage.error('登录状态已过期，请重新登录')
      // 清除 token
      removeToken()
      // 跳转到登录页
      window.location.href = '/login'
      return Promise.reject('无效的会话，或者会话已过期，请重新登录。')
    } else if (code === 500) {
      ElMessage.error(msg)
      return Promise.reject('error')
    } else if (code !== 200) {
      ElMessage.error(msg)
      return Promise.reject('error')
    } else {
      return res.data
    }
  },
  (error) => {
    console.log('err' + error)
    let { message } = error
    
    // 处理 FastAPI 返回的错误格式 {detail: "错误信息"}
    if (error.response?.data?.detail) {
      message = error.response.data.detail
    } else if (error.response?.data?.msg) {
      message = error.response.data.msg
    } else if (message == 'Network Error') {
      message = '后端接口连接异常'
    } else if (message.includes('timeout')) {
      message = '系统接口请求超时'
    } else if (message.includes('Request failed with status code')) {
      const statusCode = error.response?.status || message.substr(message.length - 3)
      message = `系统接口 ${statusCode} 异常`
    }
    
    ElMessage.error({ message: message, duration: 5 * 1000 })
    return Promise.reject(error)
  }
)

// 导出默认的 axios 实例（用于 login.js 等 API 文件）
export default api

// 创建独立的 AI 聊天 API 实例（使用独立的地址，不经过系统API代理）
const chatApi = axios.create({
  baseURL: AI_CHAT_API_BASE_URL,
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// AI 聊天 API 请求拦截器（添加 token）
chatApi.interceptors.request.use(
  (config) => {
    const token = getToken()
    if (token) {
      config.headers['Authorization'] = 'Bearer ' + token
    }
    return config
  },
  (error) => {
    return Promise.reject(error)
  }
)

// 非流式聊天接口（使用独立的 AI 对话 API）
export const chat = async (message) => {
  try {
    const response = await chatApi.post('/api/chat', {
      message,
      stream: false
    })
    return response.data
  } catch (error) {
    throw new Error(error.response?.data?.detail || error.message || '请求失败')
  }
}

// 流式聊天接口（使用 fetch + ReadableStream 处理 SSE）
export const chatStream = (message, onMessage, onError, onComplete, sessionId = null, history = null, onToolCall = null, onChart = null, onKnowledgeSearch = null, onPlan = null, checkpointId = null, onCheckpoint = null, enableTTS = false, onAudio = null, voice = 'Cherry') => {
  const controller = new AbortController()
  
  // 构建请求体
  const requestBody = {
    message,
    stream: true,
    enable_tts: enableTTS,
    voice: voice,
    language_type: 'Chinese',
    sample_rate: 24000
  }
  
  // 如果提供了sessionId，添加到请求中
  if (sessionId) {
    requestBody.session_id = sessionId
  }
  
  // 如果提供了checkpointId，添加到请求中
  if (checkpointId) {
    requestBody.checkpoint_id = checkpointId
  }
  
  // 如果提供了history，添加到请求中
  if (history && Array.isArray(history)) {
    // 只发送用户和助手消息，过滤掉流式状态的消息
    requestBody.history = history
      .filter(msg => msg.status === 'completed' && (msg.role === 'user' || msg.role === 'assistant'))
      .map(msg => ({
        role: msg.role,
        content: msg.content
      }))
  }
  
  // 构建请求头，添加 token
  const headers = {
    'Content-Type': 'application/json',
    'Accept': 'text/event-stream'
  }
  const token = getToken()
  if (token) {
    headers['Authorization'] = 'Bearer ' + token
  }
  
  // 根据是否启用TTS选择不同的接口
  const endpoint = enableTTS ? '/api/chat/stream-with-tts' : '/api/chat/stream'
  
  fetch(`${AI_CHAT_API_BASE_URL}${endpoint}`, {
    method: 'POST',
    headers: headers,
    body: JSON.stringify(requestBody),
    signal: controller.signal
  })
    .then(response => {
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`)
      }
      
      if (!response.body) {
        throw new Error('响应体不可读')
      }
      
      // 只在第一次连接时打印日志
      if (!window._sseConnectionCount) {
        window._sseConnectionCount = 0
      }
      window._sseConnectionCount++
      if (window._sseConnectionCount === 1) {
        console.log('SSE连接已建立，开始接收数据...')
      }
      
      const reader = response.body.getReader()
      const decoder = new TextDecoder()
      let buffer = ''
      let isInToolCall = false // 标记是否在工具调用过程中
      
      const readStream = () => {
        reader.read().then(({ done, value }) => {
          if (done) {
            // 流式处理完成
            if (onComplete) onComplete()
            return
          }
          
          const chunk = decoder.decode(value, { stream: true })
          buffer += chunk
          
          // SSE 格式：event: xxx\ndata: yyy\n\n
          // 事件之间用 \n\n 分隔
          let eventEndIndex
          while ((eventEndIndex = buffer.indexOf('\n\n')) !== -1) {
            const eventBlock = buffer.slice(0, eventEndIndex)
            buffer = buffer.slice(eventEndIndex + 2)
            
            if (!eventBlock.trim()) {
              // 空事件块，跳过
              continue
            }
            
            // 解析事件块
            const lines = eventBlock.split('\n')
            let event = null
            let data = ''
            
            for (const line of lines) {
              const trimmed = line.trim()
              if (!trimmed) continue
              
              if (trimmed.startsWith('event: ')) {
                event = trimmed.slice(7).trim()
              } else if (trimmed.startsWith('data: ')) {
                // 如果有多个 data 行，只取第一个（在我们的情况下不会有多个）
                data = trimmed.slice(6)
              }
            }
            
            // 处理事件
            if (data) {
              try {
                const parsedData = JSON.parse(data)
                
                if (event === 'error') {
                  if (onError) onError(parsedData.content || '发生错误')
                } else if (event === 'tool_call') {
                  // tool_call 事件：工具调用信息
                  if (parsedData.type === 'start') {
                    // 工具调用开始，标记进入工具调用状态
                    isInToolCall = true
                  } else if (parsedData.type === 'result') {
                    // 工具调用结束，标记退出工具调用状态
                    isInToolCall = false
                  }
                  if (onToolCall) onToolCall(parsedData)
                } else if (event === 'chart') {
                  // chart 事件：图表数据
                  if (onChart) onChart(parsedData)
                } else if (event === 'knowledge_search') {
                  // knowledge_search 事件：知识库搜索结果
                  if (onKnowledgeSearch) onKnowledgeSearch(parsedData)
                } else if (event === 'plan') {
                  // plan 事件：任务计划
                  if (onPlan) onPlan(parsedData)
                } else if (event === 'checkpoint') {
                  // checkpoint 事件：检查点ID
                  if (onCheckpoint) onCheckpoint(parsedData)
                } else if (event === 'audio') {
                  // audio 事件：音频数据
                  if (onAudio) onAudio(parsedData.audio)
                } else if (event === 'audio_done') {
                  // audio_done 事件：音频合成完成
                  if (onAudio) onAudio(null, true)
                } else if (event === 'message') {
                  // message 事件
                  // 过滤掉工具调用过程中的消息
                  if (!isInToolCall) {
                    if (parsedData.finished) {
                      // 流式完成
                      if (onComplete) onComplete()
                    } else if (parsedData.content !== undefined && parsedData.content !== '') {
                      if (onMessage) onMessage(parsedData.content)
                    }
                  }
                }
              } catch (e) {
                console.error('解析 SSE 数据失败:', e, '原始数据:', data)
              }
            }
          }
          
          readStream()
        }).catch(error => {
          if (error.name !== 'AbortError') {
            console.error('读取流错误:', error)
            if (onError) onError(error.message)
          }
        })
      }
      
      readStream()
    })
    .catch(error => {
      if (error.name !== 'AbortError') {
        if (onError) onError(error.message)
      }
    })
  
  // 返回取消函数
  return () => {
    controller.abort()
  }
}

// 健康检查（检查 AI 对话服务）
export const healthCheck = async () => {
  try {
    const response = await chatApi.get('/health')
    return response.data
  } catch (error) {
    throw new Error('服务器连接失败')
  }
}


